package com.hb.trade.client.center;

import cn.hutool.core.collection.CollUtil;
import com.hb.core.pojo.center.au.dto.RoleDTO;
import com.hb.core.pojo.center.au.entity.Role;
import com.hb.core.pojo.center.au.entity.User;
import com.hb.core.pojo.enums.RoleTypeEnum;
import com.hb.core.pojo.parent.PageResult;
import org.fzzn.core.model.msg.Message;
import org.fzzn.core.util.Enums;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;

import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

@FeignClient("hb-center")
public interface RoleClient {
    /**
     * 角色分页列表表信息
     *
     * @param roleDTO
     * @return
     */
    @PostMapping("/role/pageRoles")
    Message<PageResult<RoleDTO>> pageRoles(RoleDTO roleDTO);
    /**
     * 角色分页列表表信息
     *
     * @param roleDTO
     * @return
     */
    @PostMapping("/role/pageManagementRoles")
    Message<PageResult<RoleDTO>> pageManagementRoles(RoleDTO roleDTO);

    /**
     * 新增或更新角色信息
     *
     * @param roleDTO
     * @return
     */
    @PostMapping("/role/saveRole")
    Message<Boolean> saveRole(RoleDTO roleDTO);

    /**
     * 删除角色
     *
     * @return
     */
    @PostMapping("/role/removeRole")
    Message<Boolean> removeRole(RoleDTO roleDTO);

    /**
     * 更新角色的权限
     *
     * @return
     */
    @PostMapping("/role/updatePermissions")
    Message<Boolean> updatePermissions(RoleDTO roleDTO);

    /**
     * 查询指定角色下的用户成员列表
     *
     * @param roleDTO#id       角色ID
     * @param roleDTO#pageFlag 返回形式(1: 分页对象, 2: 列表对象)
     * @return
     */
    @PostMapping("/role/membersByRole")
    Message<RoleDTO> membersByRole(RoleDTO roleDTO);

    /**
     * 查询用户的业务角色列表
     *
     * @param orgOrUserId 用户或者企业ID
     * @return
     */
    @PostMapping("/role/listBiddingRoles")
    Message<List<RoleDTO>> listBiddingRoles(@RequestParam("orgOrUserId") Long orgOrUserId);

    /**
     * 角色列表
     * 20220421 v2.1.02 查询当前企业下的角色列表 + 分公司管理员(分公司管理员只有总公司有)
     *
     * @param roleDTO#roleName 角色名称查询条件
     * @return
     */
    @PostMapping("/role/listRoles")
    Message<List<Role>> listRoles(RoleDTO roleDTO);

    /**
     * 获取指定用户拥有的所有角色
     * 参数支持id和username
     *
     * @param user#id
     * @param user#username
     * @return
     */
    @PostMapping("/role/listRolesByUser")
    Message<List<RoleDTO>> listRolesByUser(User user);

    /**
     * 判断指定的用户有没有业务角色
     *
     * @param userId
     * @param roleSign
     * @return
     */
    default boolean hasRoleSign(@RequestParam("id") Long userId,
                                @RequestParam("roleSign") Integer roleSign) {
        if (userId == null || roleSign == null) {
            return false;
        }

        Message<List<RoleDTO>> listMessage = listBiddingRoles(userId);
        List<RoleDTO> data = listMessage.getData();
        if (CollUtil.isEmpty(data)) {
            return false;
        }
        for (RoleDTO datum : data) {
            Integer datumRoleSign = datum.getRoleSign();
            if (roleSign.equals(datumRoleSign)) {
                return true;
            }
        }
        return false;
    }


    /**
     * 判断指定的用户有没有管理角色
     *
     * @param userId
     * @param roleType
     * @return
     */
    default boolean hasRoleType(@RequestParam("id") Long userId,
                                @RequestParam("roleType") Integer roleType) {
        if (userId == null || roleType == null) {
            return false;
        }

        Message<List<RoleDTO>> listMessage = listBiddingRoles(userId);
        List<RoleDTO> data = listMessage.getData();
        if (CollUtil.isEmpty(data)) {
            return false;
        }
        for (RoleDTO datum : data) {
            Integer datumRoleType = datum.getRoleType();
            if (roleType.equals(datumRoleType)) {
                return true;
            }
        }
        return false;
    }

    /**
     * 角色详情(点击编辑时回显)
     *
     * @param roleDTO#id
     * @return
     */
    @PostMapping("/role/roleDetail")
    Message<RoleDTO> roleDetail(RoleDTO roleDTO);

    /**
     * 根据roleType查询角色
     *
     * @param roleType
     * @return
     */
    @PostMapping("/role/getRoleByRoleType")
    Message<Role> getRoleByRoleType(RoleTypeEnum roleType);

    /**
     * 判断指定的角色id中是否包含指定的角色类型
     *
     * @param roleIds      角色ID集合
     * @param roleTypeEnum 角色类型
     * @return 指定角色类型的角色ID
     */
    default Long hasRoleType(Set<Long> roleIds, RoleTypeEnum roleTypeEnum) {
        if (CollUtil.isEmpty(roleIds)) {
            return null;
        }
        RoleDTO roleDTO = new RoleDTO();
        for (Long roleId : roleIds) {
            roleDTO.setId(roleId);
            Message<RoleDTO> detailMsg = roleDetail(roleDTO);
            if (detailMsg.isFail()) {
                continue;
            }
            RoleDTO data = detailMsg.getData();
            Integer roleType = data.getRoleType();
            if (Enums.equals(roleTypeEnum, roleType)) {
                return roleId;
            }
        }
        return null;
    }

    /**
     * 判断指定的角色id中是否包含指定的角色类型
     *
     * @param roleList      角色的列表
     * @param roleTypeEnum 角色类型
     * @return 指定角色类型的角色ID
     */
    default Long hasRoleType(List<RoleDTO> roleList, RoleTypeEnum roleTypeEnum) {
        if (CollUtil.isEmpty(roleList)) {
            return null;
        }
        Set<Long> roleIds = roleList.stream().map(RoleDTO::getId).collect(Collectors.toSet());
        return hasRoleType(roleIds, roleTypeEnum);
    }
}
